// 传输队列页面脚本 - 重写版本

console.log('[Queue] 脚本开始加载');

// 全局变量
let allTasks = [];
let currentFilter = {
  type: 'upload',
  status: 'uploading'
};
let autoRefreshTimer = null; // 自动刷新定时器

// 分页加载相关变量
const PAGE_SIZE = 400; // 每页显示400个文件
let currentPage = 1; // 当前页码
let isLoadingMore = false; // 是否正在加载更多
let filteredTasks = []; // 存储过滤后的任务

// 主初始化函数
window.initQueue = async function() {
  console.log('[Queue] ========== 开始初始化 ==========');
  
  // 🔥 等待 DOM 完全加载并检查关键元素
  let retries = 0;
  const maxRetries = 20;
  while (retries < maxRetries) {
    await new Promise(resolve => setTimeout(resolve, 100));
    const transferList = document.getElementById('transferList');
    if (transferList) {
      console.log('[Queue] ✅ transferList 元素已找到');
      break;
    }
    retries++;
    console.log(`[Queue] 等待 transferList 元素... (${retries}/${maxRetries})`);
  }
  
  if (retries >= maxRetries) {
    console.error('[Queue] ❌ 超时：无法找到 transferList 元素');
    return;
  }
  
  console.log('[Queue] 1. 绑定上传/下载按钮');
  bindUploadDownloadButtons();
  
  console.log('[Queue] 2. 绑定状态标签');
  bindStatusTabs();
  
  console.log('[Queue] 3. 绑定操作按钮');
  bindActionButtons();
  
  console.log('[Queue] 4. 加载任务数据');
  await loadTasks();
  
  console.log('[Queue] 5. 绑定滚动监听');
  bindScrollListener();
  
  console.log('[Queue] 6. 启动自动刷新');
  startAutoRefresh();
  
  console.log('[Queue] ========== 初始化完成 ==========');
};

// 绑定上传/下载按钮（左侧菜单）
function bindUploadDownloadButtons() {
  console.log('[Queue] 开始绑定上传/下载按钮...');
  
  // 直接查找上传按钮
  const uploadBtn = document.querySelector('[data-type="upload"]');
  const downloadBtn = document.querySelector('[data-type="download"]');
  
  console.log('[Queue] 上传按钮:', uploadBtn);
  console.log('[Queue] 下载按钮:', downloadBtn);
  
  if (!uploadBtn || !downloadBtn) {
    console.error('[Queue] ❌ 未找到上传或下载按钮！');
    
    // 打印整个 contentFrame 的内容
    const contentFrame = document.querySelector('#contentFrame');
    if (contentFrame) {
      console.log('[Queue] contentFrame HTML:', contentFrame.innerHTML.substring(0, 500));
    }
    return;
  }
  
  // 绑定上传按钮
  uploadBtn.onclick = function() {
    console.log('[Queue] ✅ 上传按钮被点击！');
    
    // 切换 active 状态
    uploadBtn.classList.add('active');
    downloadBtn.classList.remove('active');
    
    // 更新过滤器
    currentFilter.type = 'upload';
    
    // 过滤并显示
    filterAndShow();
  };
  
  // 绑定下载按钮
  downloadBtn.onclick = function() {
    console.log('[Queue] ✅ 下载按钮被点击！');
    
    // 切换 active 状态
    downloadBtn.classList.add('active');
    uploadBtn.classList.remove('active');
    
    // 更新过滤器
    currentFilter.type = 'download';
    
    // 过滤并显示
    filterAndShow();
  };
  
  console.log('[Queue] ✅ 上传/下载按钮绑定完成');
}

// 绑定状态标签（上传中/已完成）
function bindStatusTabs() {
  console.log('[Queue] 开始绑定状态标签...');
  
  const tabs = document.querySelectorAll('.queue-tab');
  console.log('[Queue] 找到状态标签:', tabs.length);
  
  tabs.forEach((tab, index) => {
    const tabType = tab.dataset.tab;
    console.log(`[Queue]   标签 ${index + 1}: ${tabType}`);
    
    tab.onclick = function() {
      console.log('[Queue] ✅ 状态标签被点击:', tabType);
      
      // 切换 active
      tabs.forEach(t => t.classList.remove('active'));
      tab.classList.add('active');
      
      // 更新过滤器
      currentFilter.status = tabType;
      
      // 根据标签类型显示/隐藏按钮
      const pauseAllBtn = document.getElementById('pauseAllBtn');
      const cancelAllBtn = document.getElementById('cancelAllBtn');
      
      if (tabType === 'completed') {
        // 已完成标签：隐藏全部暂停和全部取消
        if (pauseAllBtn) pauseAllBtn.style.display = 'none';
        if (cancelAllBtn) cancelAllBtn.style.display = 'none';
      } else {
        // 传输中标签：显示全部暂停和全部取消
        if (pauseAllBtn) pauseAllBtn.style.display = '';
        if (cancelAllBtn) cancelAllBtn.style.display = '';
      }
      
      // 过滤并显示
      filterAndShow();
    };
  });
  
  console.log('[Queue] ✅ 状态标签绑定完成');
}

// 绑定操作按钮
function bindActionButtons() {
  console.log('[Queue] 开始绑定操作按钮...');
  
  const pauseAllBtn = document.getElementById('pauseAllBtn');
  const cancelAllBtn = document.getElementById('cancelAllBtn');
  
  if (pauseAllBtn) {
    pauseAllBtn.onclick = async function() {
      console.log('[Queue] 全部暂停');
      try {
        await ipcRenderer.invoke('pause-all-tasks');
        console.log('[Queue] ✅ 已暂停所有任务');
        // 重新加载任务列表
        await loadTasks();
        // 刷新页面显示
        filterAndShow();
      } catch (error) {
        console.error('[Queue] ❌ 暂停失败:', error);
      }
    };
  }
  
  if (cancelAllBtn) {
    cancelAllBtn.onclick = async function() {
      console.log('[Queue] 全部取消');
      try {
        await ipcRenderer.invoke('cancel-all-tasks');
        console.log('[Queue] ✅ 已取消所有任务');
        // 重新加载任务列表
        await loadTasks();
        // 刷新页面显示
        filterAndShow();
      } catch (error) {
        console.error('[Queue] ❌ 取消失败:', error);
      }
    };
  }
  
  console.log('[Queue] ✅ 操作按钮绑定完成');
}

// 加载任务
async function loadTasks() {
  try {
    console.log('[Queue] 开始加载任务...');
    
    // 检查 ipcRenderer 是否可用
    if (typeof require === 'function') {
      const { ipcRenderer } = require('electron');
      
      // 🔥 正确的加载逻辑：
      // 1. 内存：传输中、待处理、暂停的任务（本地缓存）
      // 2. 服务器：已完成、失败的任务（持久化存储）
      
      // 获取内存中的任务（active, pending, paused）
      const memoryTasks = await ipcRenderer.invoke('get-tasks');
      console.log('[Queue] 内存中的任务:', memoryTasks ? memoryTasks.length : 0, '个');
      
      // 获取服务器端的任务（completed, failed）- 不传status参数获取所有
      let serverTasks = [];
      try {
        const result = await ipcRenderer.invoke('get-server-transfer-tasks', {
          limit: 200 // 加载最近200个任务
        });
        
        if (result.success && result.data && result.data.tasks) {
          serverTasks = result.data.tasks.map(task => ({
            id: task.task_id,
            task_id: task.task_id,
            type: task.type,
            fileName: task.file_name,
            file_name: task.file_name,
            localPath: task.local_path,
            remotePath: task.remote_path,
            fileId: task.file_id,
            fileSize: task.file_size,
            file_size: task.file_size,
            transferred: task.transferred,
            progress: task.progress,
            speed: task.speed,
            status: task.status,
            error: task.error,
            startTime: task.start_time,
            endTime: task.end_time,
            createdAt: task.created_at,
            isServerTask: true // 标记为服务器任务
          }));
          console.log('[Queue] 服务器任务:', serverTasks.length, '个', 
            `(已完成: ${serverTasks.filter(t => t.status === 'completed').length}, ` +
            `失败: ${serverTasks.filter(t => t.status === 'failed').length})`);
        }
      } catch (serverError) {
        console.warn('[Queue] 获取服务器任务失败:', serverError.message);
      }
      
      // 🔥 合并任务，去除重复（避免本地和服务器都有同一个任务）
      const memoryTaskIds = new Set((memoryTasks || []).map(t => t.id));
      const uniqueServerTasks = serverTasks.filter(t => !memoryTaskIds.has(t.id));
      
      allTasks = [...(memoryTasks || []), ...uniqueServerTasks];
      console.log('[Queue] 合并后总任务数:', allTasks.length, '个');
      console.log('[Queue] 任务状态分布:', {
        active: allTasks.filter(t => t.status === 'active').length,
        pending: allTasks.filter(t => t.status === 'pending').length,
        paused: allTasks.filter(t => t.status === 'paused').length,
        completed: allTasks.filter(t => t.status === 'completed').length,
        failed: allTasks.filter(t => t.status === 'failed').length
      });
      
      if (allTasks.length > 0) {
        console.log('[Queue] 第一个任务示例:', JSON.stringify(allTasks[0], null, 2));
      } else {
        console.warn('[Queue] ⚠️ 任务列表为空');
      }
      
      // 显示任务
      filterAndShow();
      
      // 监听任务更新（只设置一次）
      if (!window.queueTaskListenersSet) {
        setupTaskListeners(ipcRenderer);
        window.queueTaskListenersSet = true;
      }
    } else {
      console.warn('[Queue] require 不可用，使用模拟数据');
      allTasks = [];
      filterAndShow();
    }
  } catch (error) {
    console.error('[Queue] 加载任务失败:', error);
    console.error('[Queue] 错误详情:', error.stack);
    allTasks = [];
    filterAndShow();
  }
}

// 设置任务监听器
function setupTaskListeners(ipcRenderer) {
  console.log('[Queue] 设置任务监听器');
  
  ipcRenderer.on('task-added', (event, task) => {
    console.log('[Queue] 新任务:', task.fileName);
    allTasks.unshift(task);
    filterAndShow();
  });
  
  ipcRenderer.on('task-progress', (event, task) => {
    const index = allTasks.findIndex(t => t.id === task.id);
    if (index !== -1) {
      allTasks[index] = task;
      filterAndShow();
    }
  });
  
  ipcRenderer.on('task-completed', (event, task) => {
    console.log('[Queue] ✅ 任务完成:', task.fileName);
    // 🔥 任务完成后会上传到服务器，从本地移除
    const index = allTasks.findIndex(t => t.id === task.id);
    if (index !== -1) {
      allTasks.splice(index, 1);
      console.log('[Queue] 已从本地移除完成任务');
    }
    
    // 🔥 如果当前在"已完成"标签，重新加载服务器任务
    if (currentFilter.status === 'completed') {
      console.log('[Queue] 重新加载已完成任务...');
      setTimeout(() => loadTasks(), 1000); // 延迟1秒等待服务器保存完成
    } else {
      filterAndShow();
    }
  });
  
  ipcRenderer.on('task-failed', (event, task) => {
    console.log('[Queue] ❌ 任务失败:', task.fileName, '错误:', task.error);
    // 🔥 失败任务上传到服务器后，从本地移除
    const index = allTasks.findIndex(t => t.id === task.id);
    if (index !== -1) {
      allTasks.splice(index, 1);
      console.log('[Queue] 已从本地移除失败任务');
    }
    
    // 🔥 重新加载服务器任务（失败任务会显示在"传输中"）
    console.log('[Queue] 重新加载任务以显示失败记录...');
    setTimeout(() => loadTasks(), 1000); // 延迟1秒等待服务器保存完成
  });
  
  // 🔥 监听任务移除事件
  ipcRenderer.on('task-removed', (event, task) => {
    console.log('[Queue] 任务已移除:', task.fileName);
    const index = allTasks.findIndex(t => t.id === task.id);
    if (index !== -1) {
      allTasks.splice(index, 1);
      filterAndShow();
    }
  });
}

// 过滤并显示任务
function filterAndShow(resetPage = true) {
  console.log('[Queue] 过滤任务 - 类型:', currentFilter.type, '状态:', currentFilter.status);
  
  // 重置分页（除非是加载更多）
  if (resetPage) {
    currentPage = 1;
    console.log('[Queue] 重置分页为第1页');
  }
  
  let filtered = allTasks;
  
  // 🔥 按类型过滤
  if (currentFilter.type === 'upload') {
    filtered = filtered.filter(t => t.type === 'upload');
  } else if (currentFilter.type === 'download') {
    filtered = filtered.filter(t => t.type === 'download');
  }
  
  // 🔥 按状态过滤 - 正确的业务逻辑
  if (currentFilter.status === 'uploading' || currentFilter.status === 'downloading') {
    // 传输中：显示 active, pending, paused, failed（正在传输 + 传输失败的）
    filtered = filtered.filter(t => 
      t.status === 'active' || 
      t.status === 'pending' || 
      t.status === 'paused' || 
      t.status === 'failed'
    );
    console.log('[Queue] 过滤传输中任务:', {
      active: filtered.filter(t => t.status === 'active').length,
      pending: filtered.filter(t => t.status === 'pending').length,
      paused: filtered.filter(t => t.status === 'paused').length,
      failed: filtered.filter(t => t.status === 'failed').length
    });
  } else if (currentFilter.status === 'completed') {
    // 已完成：只显示 completed（从服务器加载）
    filtered = filtered.filter(t => t.status === 'completed');
    console.log('[Queue] 过滤已完成任务:', filtered.length, '个');
  }
  
  console.log('[Queue] 过滤后任务数:', filtered.length);
  
  // 存储过滤后的任务
  filteredTasks = filtered;
  
  // 显示任务（分页）
  renderTasks();
  
  // 更新计数
  updateCounts();
}

// 渲染任务列表（分页）
function renderTasks() {
  const totalTasks = filteredTasks.length;
  console.log('[Queue] 渲染任务 - 总数:', totalTasks, '当前页:', currentPage);
  
  const emptyState = document.getElementById('emptyState');
  const transferList = document.getElementById('transferList');
  
  if (!transferList) {
    console.error('[Queue] ❌ 未找到 transferList 元素');
    return;
  }
  
  if (totalTasks === 0) {
    // 显示空状态
    console.log('[Queue] 显示空状态');
    if (emptyState) {
      emptyState.style.display = 'flex';
      // 根据上传/下载类型更新空状态文本
      const emptyText = emptyState.querySelector('.empty-text');
      if (emptyText) {
        if (currentFilter.type === 'download') {
          emptyText.textContent = '暂无下载的文件';
        } else {
          emptyText.textContent = '暂无正在上传的文件';
        }
      }
    }
    transferList.style.display = 'none';
    transferList.innerHTML = '';
    return;
  }
  
  // 隐藏空状态
  if (emptyState) emptyState.style.display = 'none';
  transferList.style.display = 'flex';
  
  // 计算要显示的任务范围
  const endIndex = currentPage * PAGE_SIZE;
  const tasksToShow = filteredTasks.slice(0, endIndex);
  const hasMore = endIndex < totalTasks;
  
  console.log('[Queue] 显示任务:', tasksToShow.length, '/', totalTasks, '有更多:', hasMore);
  
  // 渲染任务
  const html = tasksToShow.map((task, index) => {
    // 兼容多种字段名
    const taskId = task.id || task.task_id || task.taskId;
    const name = task.fileName || task.file_name || task.name || '未知文件';
    const progress = task.progress || 0;
    const type = task.type || 'upload';
    const status = task.status || 'pending';
    const fileSize = task.file_size || task.fileSize || 0;
    const transferred = task.transferred || 0;
    
    console.log(`[Queue] 渲染任务 ${index + 1}:`, name, '类型:', type, '状态:', status, '进度:', progress);
    
    // 获取文件图标
    const icon = getFileIcon(name);
    
    // 格式化文件大小
    const sizeText = formatFileSize(transferred, fileSize);
    
    // 获取状态文本和类名
    const statusInfo = getStatusInfo(task);
    
    // 根据状态生成操作按钮
    let actionButtons = '';
    if (status === 'completed') {
      // 已完成：不显示操作按钮
      actionButtons = '';
    } else if (status === 'active') {
      // 传输中：显示暂停和取消
      actionButtons = `
        <span class="transfer-action" onclick="pauseTask('${taskId}')">暂停</span>
        <span class="transfer-action" onclick="cancelTask('${taskId}')">取消</span>
      `;
    } else if (status === 'paused') {
      // 已暂停：显示继续和取消
      actionButtons = `
        <span class="transfer-action" onclick="resumeTask('${taskId}')">继续</span>
        <span class="transfer-action" onclick="cancelTask('${taskId}')">取消</span>
      `;
    } else if (status === 'failed') {
      // 失败：显示重试和取消
      actionButtons = `
        <span class="transfer-action" onclick="retryTask('${taskId}')">重试</span>
        <span class="transfer-action" onclick="cancelTask('${taskId}')">取消</span>
      `;
    } else if (status === 'pending') {
      // 等待中：显示取消
      actionButtons = `
        <span class="transfer-action" onclick="cancelTask('${taskId}')">取消</span>
      `;
    }
    
    return `
      <div class="transfer-item" data-id="${taskId}">
        <div class="transfer-icon">${icon}</div>
        <div class="transfer-name">${name}</div>
        <div class="transfer-size">${sizeText}</div>
        <div class="transfer-status ${statusInfo.className}">${statusInfo.text}</div>
        <div class="transfer-actions">
          ${actionButtons}
        </div>
      </div>
    `;
  }).join('');
  
  // 添加加载更多提示
  let loadingHtml = '';
  if (hasMore) {
    loadingHtml = `
      <div class="load-more-indicator" style="text-align: center; padding: 20px; color: #999; font-size: 14px;">
        🔽 滚动到底部加载更多... (已显示 ${tasksToShow.length} / ${totalTasks})
      </div>
    `;
  } else if (totalTasks > PAGE_SIZE) {
    loadingHtml = `
      <div class="load-more-indicator" style="text-align: center; padding: 20px; color: #999; font-size: 14px;">
        ✅ 已加载全部 ${totalTasks} 个任务
      </div>
    `;
  }
  
  transferList.innerHTML = html + loadingHtml;
  console.log('[Queue] ✅ 任务列表渲染完成');
}

// 获取文件图标（使用与文件页面相同的 SVG 图标）
function getFileIcon(filename) {
  const ext = filename.split('.').pop().toLowerCase();
  
  // 图片文件
  const imageExts = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg', 'ico', 'tif', 'tiff'];
  if (imageExts.includes(ext)) {
    return '<img src="./assets/Photo.svg" alt="图片" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // 视频文件
  const videoExts = ['mp4', 'avi', 'mkv', 'mov', 'wmv', 'flv', 'webm', 'm4v', 'mpg', 'mpeg'];
  if (videoExts.includes(ext)) {
    return '<img src="./assets/Video.svg" alt="视频" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // 链接文件
  const linkExts = ['url', 'lnk', 'link', 'webloc', 'desktop'];
  if (linkExts.includes(ext)) {
    return '<img src="./assets/Url.svg" alt="链接" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // 音乐文件
  const musicExts = ['mp3', 'wav', 'flac', 'aac', 'm4a', 'ogg', 'wma', 'ape', 'alac'];
  if (musicExts.includes(ext)) {
    return '<img src="./assets/Music.svg" alt="音乐" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // 表格文件
  const spreadsheetExts = ['xls', 'xlsx', 'xlsm', 'csv', 'ods'];
  if (spreadsheetExts.includes(ext)) {
    return '<img src="./assets/Xls.svg" alt="表格" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // Word文档
  const wordExts = ['doc', 'docx', 'docm', 'dot', 'dotx', 'odt'];
  if (wordExts.includes(ext)) {
    return '<img src="./assets/Word.svg" alt="Word" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // 文本文件
  const textExts = ['txt', 'text', 'log'];
  if (textExts.includes(ext)) {
    return '<img src="./assets/Txt.svg" alt="文本" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // 压缩文件
  const archiveExts = ['zip', 'rar', '7z', 'tar', 'gz', 'bz2', 'xz', 'iso'];
  if (archiveExts.includes(ext)) {
    return '<img src="./assets/Zip.svg" alt="压缩" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // 代码文件
  const codeExts = ['js', 'jsx', 'ts', 'tsx', 'py', 'java', 'c', 'cpp', 'h', 'hpp', 'cs', 'php', 'rb', 'go', 'rs', 'swift', 'kt', 'vue', 'html', 'css', 'scss', 'sass', 'less', 'json', 'xml', 'yaml', 'yml', 'sh', 'bash', 'md', 'markdown'];
  if (codeExts.includes(ext)) {
    return '<img src="./assets/Dm.svg" alt="代码" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // 配置文件
  const configExts = ['ini', 'conf', 'config', 'cfg', 'properties', 'env', 'toml', 'editorconfig', 'npmrc', 'gitignore'];
  if (configExts.includes(ext)) {
    return '<img src="./assets/Pz.svg" alt="配置" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // PDF文件
  if (ext === 'pdf') {
    return '<img src="./assets/PDF.svg" alt="PDF" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // PPT文件
  const pptExts = ['ppt', 'pptx', 'pptm', 'potx', 'ppsx'];
  if (pptExts.includes(ext)) {
    return '<img src="./assets/PPT.svg" alt="PPT" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // 3D模型文件
  const modelExts = ['obj', 'fbx', '3ds', 'stl', 'dae', 'gltf', 'glb', 'blend', 'max', 'c4d', 'ma', 'mb'];
  if (modelExts.includes(ext)) {
    return '<img src="./assets/3D.svg" alt="3D" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // 数据库文件
  const dbExts = ['sql', 'db', 'sqlite', 'sqlite3', 'mdb', 'accdb', 'dbf', 'sdf'];
  if (dbExts.includes(ext)) {
    return '<img src="./assets/sql.svg" alt="数据库" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
  }
  
  // 其他所有文件使用404.svg图标
  return '<img src="./assets/404.svg" alt="未知" style="width: 20.16px; height: 20.16px; vertical-align: middle;">';
}

// 格式化文件大小
function formatFileSize(transferred, total) {
  const formatBytes = (bytes) => {
    if (bytes === 0) return '0 B';
    const k = 1024;
    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
    const i = Math.floor(Math.log(bytes) / Math.log(k));
    return (bytes / Math.pow(k, i)).toFixed(2) + ' ' + sizes[i];
  };
  
  return `${formatBytes(transferred)}/${formatBytes(total)}`;
}

// 获取状态信息
function getStatusInfo(task) {
  const progress = Math.round(task.progress || 0);
  const type = task.type || 'upload';
  const status = task.status || 'pending';
  
  if (status === 'completed') {
    return {
      text: '已完成',
      className: 'completed'
    };
  } else if (status === 'paused') {
    return {
      text: '已暂停',
      className: 'paused'
    };
  } else if (status === 'failed') {
    return {
      text: task.error || '传输失败',
      className: 'failed'
    };
  } else if (status === 'active') {
    const action = type === 'upload' ? '正在上传' : '正在下载';
    return {
      text: `${action}: ${progress}%`,
      className: 'active'
    };
  } else if (status === 'pending') {
    return {
      text: '等待中...',
      className: 'pending'
    };
  } else {
    return {
      text: '未知状态',
      className: 'unknown'
    };
  }
}

// 更新计数
function updateCounts() {
  let tasks = allTasks;
  
  // 只计数当前类型的任务
  if (currentFilter.type === 'upload') {
    tasks = tasks.filter(t => t.type === 'upload');
  } else if (currentFilter.type === 'download') {
    tasks = tasks.filter(t => t.type === 'download');
  }
  
  const activeCount = tasks.filter(t => t.status !== 'completed').length;
  const completedCount = tasks.filter(t => t.status === 'completed').length;
  
  const tabs = document.querySelectorAll('.queue-tab');
  tabs.forEach(tab => {
    const type = tab.dataset.tab;
    const span = tab.querySelector('span');
    
    if (span) {
      if (type === 'uploading') {
        const label = currentFilter.type === 'upload' ? '上传中' : '下载中';
        span.textContent = `${label}(${activeCount})`;
      } else if (type === 'completed') {
        span.textContent = `已完成(${completedCount})`;
      }
    }
  });
}

// 任务操作函数（全局）
window.pauseTask = async function(taskId) {
  console.log('[Queue] 暂停任务:', taskId);
  try {
    await ipcRenderer.invoke('pause-task', taskId);
    console.log('[Queue] ✅ 任务已暂停:', taskId);
    // 重新加载任务列表
    await loadTasks();
    // 刷新页面显示
    filterAndShow();
  } catch (error) {
    console.error('[Queue] ❌ 暂停失败:', error);
  }
};

window.resumeTask = async function(taskId) {
  console.log('[Queue] 继续任务:', taskId);
  try {
    await ipcRenderer.invoke('resume-task', taskId);
    console.log('[Queue] ✅ 任务已继续:', taskId);
    // 重新加载任务列表
    await loadTasks();
    // 刷新页面显示
    filterAndShow();
  } catch (error) {
    console.error('[Queue] ❌ 继续失败:', error);
  }
};

window.cancelTask = async function(taskId) {
  console.log('[Queue] 取消任务:', taskId);
  try {
    await ipcRenderer.invoke('cancel-task', taskId);
    console.log('[Queue] ✅ 任务已取消:', taskId);
    // 重新加载任务列表
    await loadTasks();
    // 刷新页面显示
    filterAndShow();
  } catch (error) {
    console.error('[Queue] ❌ 取消失败:', error);
  }
};

window.retryTask = async function(taskId) {
  console.log('[Queue] 重试任务:', taskId);
  try {
    await ipcRenderer.invoke('retry-task', taskId);
    console.log('[Queue] ✅ 任务已重试:', taskId);
    // 重新加载任务列表
    await loadTasks();
    // 刷新页面显示
    filterAndShow();
  } catch (error) {
    console.error('[Queue] ❌ 重试失败:', error);
  }
};

window.removeTask = async function(taskId) {
  console.log('[Queue] 移除任务:', taskId);
  try {
    // 从本地移除
    allTasks = allTasks.filter(t => t.id !== taskId);
    console.log('[Queue] ✅ 任务已移除:', taskId);
    // 重新渲染
    filterAndShow();
  } catch (error) {
    console.error('[Queue] ❌ 移除失败:', error);
  }
};

// 绑定滚动监听（用于无限滚动加载）
function bindScrollListener() {
  const queueContent = document.querySelector('.queue-content');
  if (!queueContent) {
    console.warn('[Queue] ⚠️ 未找到 .queue-content 元素，无法绑定滚动监听');
    return;
  }
  
  queueContent.addEventListener('scroll', () => {
    // 如果正在加载，不重复加载
    if (isLoadingMore) return;
    
    // 检查是否有更多内容
    const totalTasks = filteredTasks.length;
    const loadedCount = currentPage * PAGE_SIZE;
    if (loadedCount >= totalTasks) return;
    
    // 检查是否滚动到底部（提前100px开始加载）
    const scrollTop = queueContent.scrollTop;
    const scrollHeight = queueContent.scrollHeight;
    const clientHeight = queueContent.clientHeight;
    
    if (scrollTop + clientHeight >= scrollHeight - 100) {
      console.log('[Queue] 🔽 检测到滚动到底部，加载更多...');
      loadMoreTasks();
    }
  });
  
  console.log('[Queue] ✅ 滚动监听已绑定');
}

// 加载更多任务
function loadMoreTasks() {
  if (isLoadingMore) return;
  
  const totalTasks = filteredTasks.length;
  const loadedCount = currentPage * PAGE_SIZE;
  
  if (loadedCount >= totalTasks) {
    console.log('[Queue] 已加载全部任务');
    return;
  }
  
  isLoadingMore = true;
  currentPage++;
  console.log('[Queue] 加载第', currentPage, '页，每页', PAGE_SIZE, '个');
  
  // 重新渲染（不重置分页）
  renderTasks();
  
  isLoadingMore = false;
  console.log('[Queue] ✅ 加载更多完成，当前显示:', currentPage * PAGE_SIZE, '/', totalTasks);
}

// 启动自动刷新（10秒间隔）
function startAutoRefresh() {
  // 清除之前的定时器（如果有）
  if (autoRefreshTimer) {
    clearInterval(autoRefreshTimer);
  }
  
  // 设置10秒刷新一次
  autoRefreshTimer = setInterval(async () => {
    console.log('[Queue] 🔄 自动刷新任务列表...');
    try {
      await loadTasks();
      // 不重置分页，保持用户当前浏览位置
      filterAndShow(false);
      console.log('[Queue] ✅ 自动刷新完成');
    } catch (error) {
      console.error('[Queue] ❌ 自动刷新失败:', error);
    }
  }, 10000); // 10秒 = 10000毫秒
  
  console.log('[Queue] ✅ 自动刷新已启动，间隔: 10秒');
}

// 停止自动刷新
function stopAutoRefresh() {
  if (autoRefreshTimer) {
    clearInterval(autoRefreshTimer);
    autoRefreshTimer = null;
    console.log('[Queue] 自动刷新已停止');
  }
}

// 页面卸载时清理定时器
window.addEventListener('beforeunload', () => {
  stopAutoRefresh();
});

// 导出全局函数供使用
window.queueLoadTasks = loadTasks;
window.queueStartAutoRefresh = startAutoRefresh;
window.queueStopAutoRefresh = stopAutoRefresh;

console.log('[Queue] 脚本加载完成');
